#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
飞书同步管理器
负责与飞书API交互，将处理完成的文章同步到飞书
"""
import re
import lark_oapi as lark
from lark_oapi.api.bitable.v1 import *
import json
from datetime import datetime

from readlater.database.db_manager import DatabaseManager
from readlater.config.config_manager import ConfigManager
from readlater.utils.logger import get_logger


class FeishuSyncManager:
    """飞书同步管理器类"""

    def __init__(self, db_path=None):
        """
        初始化飞书同步管理器

        Args:
            db_path: 数据库文件路径, 如果为None则使用默认路径
        """
        # 初始化日志记录器
        self.logger = get_logger(__name__)
        self.config = ConfigManager()
        self.db_manager = DatabaseManager(self.config.get_database_path())

        # 飞书API相关配置
        # 注意：实际使用时需要从配置文件或环境变量加载
        self.app_id = self.config.get('feishu.app_id', env_var=True)
        self.app_secret = self.config.get('feishu.app_secret', env_var=True)
        self.app_token = self.config.get('feishu.app_token', env_var=True)
        self.table_id = self.config.get('feishu.table_id', env_var=True)

        self._mask_sensitive_info()

        self.client = lark.Client.builder() \
            .app_id(self.app_id) \
            .app_secret(self.app_secret) \
            .domain(lark.FEISHU_DOMAIN) \
            .enable_set_token(False) \
            .log_level(lark.LogLevel.DEBUG) \
            .build()

    def sync(self):
        """
        将已处理的文章同步到飞书

        Returns:
            [str]: 成功同步的文章ID列表
            [str]: 失败同步的文章ID列表
            [str]: 重复的文章ID列表
        """
        articles = self.get_processed_articles()
        return self.sync_to_feishu(articles)

    def get_processed_articles(self):
        """
        从数据库查询status为processed的文章记录

        Returns:
            list: 包含所有已处理文章记录的列表，每条记录为字典形式
        """
        try:
            # 连接数据库
            if not self.db_manager.connect():
                self.logger.error("数据库连接失败，无法查询已处理文章")
                return []

            # 查询已AI处理的文章
            results = self.db_manager.get_articles_by_status(
                DatabaseManager.STATUS_PROCESSED)
            return results
        except Exception as e:
            self.logger.error(f"查询已处理文章失败: {str(e)}")
            return []
        finally:
            # 关闭数据库连接
            self.db_manager.close()

    def _update_article(self, article_id, feishu_record_id, status=DatabaseManager.STATUS_SYNCED):
        """
        更新文章状态

        Args:
            article_id: 文章ID
            status: 新状态
        """
        try:
            if not self.db_manager.connect():
                self.logger.error("数据库连接失败，无法更新文章状态")
                return False

            return self.db_manager.update_article(article_id, feishu_record_id=feishu_record_id, status=status)
        except Exception as e:
            self.logger.error(f"更新文章状态失败: {str(e)}")
            return False
        finally:
            self.db_manager.close()

    def sync_to_feishu(self, articles):
        """
        将已处理的文章同步到飞书
        注意：此方法需要实现飞书API调用逻辑

        Returns:
            [str]: 成功同步的文章ID列表
            [str]: 失败同步的文章ID列表
            [str]: 重复的文章ID列表
        """
        # 初始化计数器
        success = []
        failed = []
        duplicated = []

        if not articles:
            self.logger.info("没有需要同步的文章")
            return success, failed, duplicated

        # 遍历文章进行同步
        for article in articles:
            article_id = article.get('id')
            if not article_id:
                self.logger.warning("文章ID不存在，跳过处理")
                failed.append(article_id)
                continue

            # 查询飞书表格中是否已存在该文章
            if self._is_article_exists(article):
                self.logger.info(f"文章已存在，跳过同步: {article_id}")
                duplicated.append(article_id)
                continue

            # 新增文章到飞书表格
            if self._add_article_to_feishu(article):
                self.logger.info(f"文章同步成功: {article_id}")
                success.append(article_id)
            else:
                self.logger.error(f"文章同步失败: {article_id}")
                failed.append(article_id)

        # 同步完成，输出统计信息
        self.logger.info(f"飞书同步完成 - "
                         f"重复: {duplicated}, 成功: {success}, 失败: {failed}")
        return success, failed, duplicated

    def _is_article_exists(self, article):
        """
        检查飞书表格中是否已存在指定ID文章

        Args:
            article_id: 文章ID

        Returns:
            bool: 存在返回True，不存在返回False
        """
        if article.get('feishu_record_id'):
            return True

        article_id = article.get('id')

        request: SearchAppTableRecordRequest = SearchAppTableRecordRequest.builder() \
            .app_token(self.app_token) \
            .table_id(self.table_id) \
            .page_size(1) \
            .request_body(SearchAppTableRecordRequestBody.builder()
                          .field_names(["id"])
                          .filter(FilterInfo.builder()
                                  .conjunction("and")
                                  .conditions([Condition.builder()
                                               .field_name("id")
                                               .operator("is")
                                               .value([article_id])
                                               .build()
                                               ])
                                  .build())
                          .automatic_fields(False)
                          .build()) \
            .build()

        # 发起请求
        response: SearchAppTableRecordResponse = self.client.bitable.v1.app_table_record.search(
            request)
        if response.code != 0:
            self.logger.error(f"查询文章失败: {response.msg}")
            return False

        if response.data.items:
            record_id = response.data.items[0].record_id
            return self._update_article(article_id, feishu_record_id=record_id)
        else:
            return False

    def _add_article_to_feishu(self, article):
        """
        将文章添加到飞书表格

        Args:
            article: 文章数据字典

        Returns:
            bool: 添加成功返回record_id，失败返回None
        """
        article_id = article.get('id')
        article_title = article.get('title')
        article_url = article.get('url')
        article_summary = article.get('summary')
        article_tags = [tag.strip() for tag in article.get('tags').split(',')]
        article_datetime = article.get('datetime')
        try:
            # 处理datetime对象或ISO格式字符串
            if isinstance(article_datetime, datetime):
                parsed_datetime = article_datetime
            else:
                # 尝试解析ISO格式字符串（如'2023-10-01T12:34:56'）
                parsed_datetime = datetime.fromisoformat(article_datetime)

            # 格式化为 Unix 时间戳格式（毫秒级），例如：1674206443000
            article_update_time = parsed_datetime.timestamp() * 1000
        except (TypeError, ValueError) as e:
            self.logger.error(f"日期时间格式转换失败: {str(e)}, 原始值: {article_datetime}")
            article_update_time = ""

        feishu_record = {
            "id": article_id,
            "标题": article_title,
            "url": {
                "text": article_title,
                "link": article_url,
            },
            "摘要": article_summary,
            "标签": article_tags,
            "更新日期": article_update_time,
        }
        request: CreateAppTableRecordRequest = CreateAppTableRecordRequest.builder() \
            .app_token(self.app_token) \
            .table_id(self.table_id) \
            .request_body(AppTableRecord.builder()
                          .fields(feishu_record)
                          .build()) \
            .build()

        response: CreateAppTableRecordResponse = self.client.bitable.v1.app_table_record.create(
            request)

        # 处理失败返回
        if not response.success():
            self.logger.error(
                f"client.bitable.v1.app_table_record.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}")
            return None

        # 处理业务结果
        self.logger.info(
            f"同步文章{article_title}成功: {lark.JSON.marshal(response.data, indent=4)}")
        record_id = response.data.record.record_id
        if self._update_article(article_id, feishu_record_id=record_id):
            return record_id
        else:
            return None

    def _mask_sensitive_info(self):
        """
        屏蔽敏感信息
        """
        appid = self.app_id[0:4] + len(self.app_id[4:])*'*'
        appsecret = self.app_secret[0:4] + len(self.app_secret[4:])*'*'
        apptoken = self.app_token
        tableid = self.table_id
        self.logger.info(
            f"飞书配置: app_id={appid}, app_secret={appsecret}, app_token={apptoken}, table_id={tableid}")
